home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gspath1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-19  |  10.8 KB  |  375 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gspath1.c */
  20. /* Additional PostScript Level 1 path routines for Ghostscript library */
  21. #include "math_.h"
  22. #include "gx.h"
  23. #include "gserrors.h"
  24. #include "gsstruct.h"
  25. #include "gxfixed.h"
  26. #include "gxfarith.h"
  27. #include "gxmatrix.h"
  28. #include "gzstate.h"
  29. #include "gspath.h"
  30. #include "gzpath.h"
  31. #include "gscoord.h"            /* gs_itransform prototype */
  32.  
  33. /* ------ Arcs ------ */
  34.  
  35. /* Conversion parameters */
  36. #define degrees_to_radians (M_PI / 180.0)
  37.  
  38. /* Forward declarations */
  39. /*
  40.  * Because of an obscure bug in the IBM RS/6000 compiler, the int argument
  41.  * for arc_add must come before the floatp arguments.
  42.  */
  43. typedef enum {
  44.   arc_nothing,
  45.   arc_moveto,
  46.   arc_lineto
  47. } arc_action;
  48. private int arc_add(P10(gs_state *, arc_action, segment_notes,
  49.   floatp, floatp, floatp, floatp, floatp, floatp, floatp));
  50.  
  51. int
  52. gs_arc(gs_state *pgs,
  53.   floatp xc, floatp yc, floatp r, floatp ang1, floatp ang2)
  54. {    return gs_arc_add(pgs, false, xc, yc, r, ang1, ang2, true);
  55. }
  56.  
  57. int
  58. gs_arcn(gs_state *pgs,
  59.   floatp xc, floatp yc, floatp r, floatp ang1, floatp ang2)
  60. {    return gs_arc_add(pgs, true, xc, yc, r, ang1, ang2, true);
  61. }
  62.  
  63. int
  64. gs_arc_add(gs_state *pgs, bool clockwise, floatp axc, floatp ayc, floatp arad,
  65.   floatp aang1, floatp aang2, bool add_line)
  66. {    double ar = arad;
  67.     fixed ang1 = float2fixed(aang1), ang2 = float2fixed(aang2), adiff;
  68.     double ang1r;        /* reduced angle */
  69.     gs_sincos_t sincos;
  70.     double x0, y0, sin0, cos0;
  71.     double x3r, y3r;
  72.     arc_action action = (add_line ? arc_lineto : arc_moveto);
  73.     segment_notes notes = sn_none;
  74.     int code;
  75.  
  76. #define fixed_90 int2fixed(90)
  77. #define fixed_180 int2fixed(180)
  78. #define fixed_360 int2fixed(360)
  79.     if ( ar < 0 )
  80.        {    ang1 += fixed_180;
  81.         ang2 += fixed_180;
  82.         ar = - ar;
  83.        }
  84.     ang1r = fixed2float(ang1 % fixed_360);
  85.     gs_sincos_degrees(ang1r, &sincos);
  86.     sin0 = ar * sincos.sin, cos0 = ar * sincos.cos;
  87.     x0 = axc + cos0, y0 = ayc + sin0;
  88.     if ( clockwise )
  89.        {    /* Quadrant reduction */
  90.         while ( ang1 < ang2 ) ang2 -= fixed_360;
  91.         while ( (adiff = ang2 - ang1) < -fixed_90 )
  92.            {    double w = sin0; sin0 = -cos0; cos0 = w;
  93.             x3r = axc + cos0, y3r = ayc + sin0;
  94.             code = arc_add(pgs, action, notes,
  95.                        ar, x0, y0, x3r, y3r,
  96.                        x0 + cos0, y0 + sin0);
  97.             if ( code < 0 ) return code;
  98.             x0 = x3r, y0 = y3r;
  99.             ang1 -= fixed_90;
  100.             action = arc_nothing;
  101.             notes = sn_not_first;
  102.            }
  103.        }
  104.     else
  105.        {    /* Quadrant reduction */
  106.         while ( ang2 < ang1 ) ang2 += fixed_360;
  107.         while ( (adiff = ang2 - ang1) > fixed_90 )
  108.            {    double w = cos0; cos0 = -sin0; sin0 = w;
  109.             x3r = axc + cos0, y3r = ayc + sin0;
  110.             code = arc_add(pgs, action, notes,
  111.                        ar, x0, y0, x3r, y3r,
  112.                        x0 + cos0, y0 + sin0);
  113.             if ( code < 0 ) return code;
  114.             x0 = x3r, y0 = y3r;
  115.             ang1 += fixed_90;
  116.             action = arc_nothing;
  117.             notes = sn_not_first;
  118.            }
  119.        }
  120.     /* Compute the intersection of the tangents. */
  121.     /* We define xt and yt as separate variables to work around */
  122.     /* a floating point bug in one of the SPARC compilers. */
  123.     /* We know that -fixed_90 <= adiff <= fixed_90. */
  124.        {    double trad =
  125.           tan(fixed2float(adiff) * (degrees_to_radians / 2));
  126.         double xt = x0 - trad * sin0, yt = y0 + trad * cos0;
  127.         gs_sincos_degrees(fixed2float(ang2), &sincos);
  128.         code = arc_add(pgs, action, notes,
  129.                    ar, x0, y0,
  130.                    (axc + ar * sincos.cos),
  131.                    (ayc + ar * sincos.sin),
  132.                    xt, yt);
  133.        }
  134.     return code;
  135. }
  136.  
  137. int
  138. gs_arcto(gs_state *pgs,
  139.   floatp ax1, floatp ay1, floatp ax2, floatp ay2, floatp arad, float retxy[4])
  140. {    double xt0, yt0, xt2, yt2;
  141.     gs_point up0;
  142. #define ax0 up0.x
  143. #define ay0 up0.y
  144.     int code;
  145.     if ( arad < 0 )
  146.         return_error(gs_error_undefinedresult);
  147.     /* Transform the current point back into user coordinates */
  148.     if ( (code = gs_currentpoint(pgs, &up0)) < 0 ) return code;
  149.        {    /* Now we have to compute the tangent points. */
  150.         /* Basically, the idea is to compute the tangent */
  151.         /* of the bisector by using tan(x+y) and tan(z/2) */
  152.         /* formulas, without ever using any trig. */
  153.         double dx0 = ax0 - ax1, dy0 = ay0 - ay1;
  154.         double dx2 = ax2 - ax1, dy2 = ay2 - ay1;
  155.         /* Compute the squared lengths from p1 to p0 and p2. */
  156.         double sql0 = dx0 * dx0 + dy0 * dy0;
  157.         double sql2 = dx2 * dx2 + dy2 * dy2;
  158.         /* Compute the distance from p1 to the tangent points. */
  159.         /* This is the only hairy part. */
  160.         double num = dy0 * dx2 - dy2 * dx0;
  161.         double denom = sqrt(sql0 * sql2) - (dx0 * dx2 + dy0 * dy2);
  162.         /* Check for collinear points. */
  163.         if ( fabs(num) < 1.0e-6 || fabs(denom) < 1.0e-6 )
  164.            {    gs_fixed_point pt;
  165.             code = gs_point_transform2fixed(&pgs->ctm, ax1, ay1, &pt);
  166.             if ( code >= 0 )
  167.               code = gx_path_add_line(pgs->path, pt.x, pt.y);
  168.             xt0 = xt2 = ax1;
  169.             yt0 = yt2 = ay1;
  170.            }
  171.         else        /* not collinear */
  172.            {    double dist = fabs(arad * num / denom);
  173.             double l0 = dist / sqrt(sql0), l2 = dist / sqrt(sql2);
  174.             xt0 = ax1 + dx0 * l0;
  175.             yt0 = ay1 + dy0 * l0;
  176.             xt2 = ax1 + dx2 * l2;
  177.             yt2 = ay1 + dy2 * l2;
  178.             code = arc_add(pgs, arc_lineto, sn_none,
  179.                        arad, xt0, yt0, xt2, yt2, ax1, ay1);
  180.            }
  181.        }
  182.     if ( retxy != 0 )
  183.        {    retxy[0] = xt0;
  184.         retxy[1] = yt0;
  185.         retxy[2] = xt2;
  186.         retxy[3] = yt2;
  187.        }
  188.     return code;
  189. }
  190.  
  191. /* Internal routine for adding an arc to the path. */
  192. private int
  193. arc_add(gs_state *pgs, arc_action action, segment_notes notes,
  194.   floatp r, floatp x0, floatp y0, floatp x3, floatp y3, floatp xt, floatp yt)
  195. {    gx_path *path = pgs->path;
  196.     floatp dx = xt - x0, dy = yt - y0;
  197.     double dist = dx * dx + dy * dy;
  198.     double r2 = r * r;
  199.     floatp fraction;
  200.     gs_fixed_point p0, p3, pt, cpt;
  201.     int code;
  202.     /* Compute the fraction coefficient for the curve. */
  203.     /* See gx_path_add_partial_arc for details. */
  204.     if ( dist >= r2 * 1.0e8 )    /* almost zero radius; */
  205.                 /* the >= catches dist == r == 0 */
  206.       fraction = 0.0;
  207.     else
  208.       fraction = (4.0/3.0) / (1 + sqrt(1 + dist / r2));
  209.     if_debug8('r',
  210.           "[r]Arc f=%f p0=(%f,%f) pt=(%f,%f) p3=(%f,%f) action=%d\n",
  211.           fraction, x0, y0, xt, yt, x3, y3, (int)action);
  212.     if (    (code = gs_point_transform2fixed(&pgs->ctm, x0, y0, &p0)) < 0 ||
  213.         (code = gs_point_transform2fixed(&pgs->ctm, x3, y3, &p3)) < 0 ||
  214.         (code = gs_point_transform2fixed(&pgs->ctm, xt, yt, &pt)) < 0 ||
  215.         (code =
  216.          (action == arc_nothing ? 0 :
  217.           action == arc_lineto &&
  218.            gx_path_current_point(path, &cpt) >= 0 ?
  219.           gx_path_add_line(path, p0.x, p0.y) :
  220.           /* action == arc_moveto */
  221.           gx_path_add_point(path, p0.x, p0.y))) < 0
  222.        )
  223.       return code;
  224.     return gx_path_add_partial_arc_notes(path, p3.x, p3.y, pt.x, pt.y,
  225.                          fraction, notes);
  226. }
  227.  
  228. /* ------ Path transformers ------ */
  229.  
  230. int
  231. gs_dashpath(gs_state *pgs)
  232. {    gx_path fpath;
  233.     int code;
  234.  
  235.     if ( gs_currentdash_length == 0 )
  236.       return 0;            /* no dash pattern */
  237.     code = gs_flattenpath(pgs);
  238.     if ( code < 0 )
  239.       return code;
  240.     code = gx_path_expand_dashes(pgs->path, &fpath,
  241.                      (const gs_imager_state *)pgs);
  242.     if ( code < 0 )
  243.       return code;
  244.     gx_path_release(pgs->path);
  245.     *pgs->path = fpath;
  246.     return 0;
  247. }
  248.  
  249. int
  250. gs_flattenpath(gs_state *pgs)
  251. {    gx_path fpath;
  252.     int code;
  253.     if ( !pgs->path->curve_count ) return 0;    /* no curves */
  254.     code = gx_path_flatten_accurate(pgs->path, &fpath, pgs->flatness,
  255.                     pgs->accurate_curves);
  256.     if ( code < 0 ) return code;
  257.     gx_path_release(pgs->path);
  258.     *pgs->path = fpath;
  259.     return 0;
  260. }
  261.  
  262. int
  263. gs_reversepath(gs_state *pgs)
  264. {    gx_path rpath;
  265.     int code = gx_path_copy_reversed(pgs->path, &rpath, 1);
  266.     if ( code < 0 ) return code;
  267.     gx_path_release(pgs->path);
  268.     *pgs->path = rpath;
  269.     return 0;
  270. }
  271.  
  272. /* ------ Accessors ------ */
  273.  
  274. int
  275. gs_upathbbox(gs_state *pgs, gs_rect *pbox, bool include_moveto)
  276. {    gs_fixed_rect fbox;        /* box in device coordinates */
  277.     gs_rect dbox;
  278.     int code = gx_path_bbox(pgs->path, &fbox);
  279.  
  280.     if ( code < 0 )
  281.       return code;
  282.     /* If the path ends with a moveto and include_moveto is true, */
  283.     /* include the moveto in the bounding box. */
  284.     if ( path_last_is_moveto(pgs->path) && include_moveto )
  285.       { gs_fixed_point pt;
  286.         gx_path_current_point_inline(pgs->path, &pt);
  287.         if ( pt.x < fbox.p.x )
  288.           fbox.p.x = pt.x;
  289.         if ( pt.y < fbox.p.y )
  290.           fbox.p.y = pt.y;
  291.         if ( pt.x > fbox.q.x )
  292.           fbox.q.x = pt.x;
  293.         if ( pt.y > fbox.q.y )
  294.           fbox.q.y = pt.y;
  295.       }
  296.     /* Transform the result back to user coordinates. */
  297.     dbox.p.x = fixed2float(fbox.p.x);
  298.     dbox.p.y = fixed2float(fbox.p.y);
  299.     dbox.q.x = fixed2float(fbox.q.x);
  300.     dbox.q.y = fixed2float(fbox.q.y);
  301.     return gs_bbox_transform_inverse(&dbox, &ctm_only(pgs), pbox);
  302. }
  303.  
  304. /* ------ Enumerators ------ */
  305.  
  306. /* Start enumerating a path */
  307. int
  308. gs_path_enum_init(gs_path_enum *penum, const gs_state *pgs)
  309. {    gx_path *copied_path = gx_path_alloc(pgs->memory, "gs_path_enum_init");
  310.     int code;
  311.  
  312.     if ( copied_path == 0 )
  313.       return_error(gs_error_VMerror);
  314.     code = gx_path_copy(pgs->path, copied_path, 1);
  315.     if ( code < 0 )
  316.     {    gs_free_object(pgs->memory, copied_path, "gs_path_enum_init");
  317.         return code;
  318.     }
  319.     gx_path_enum_init(penum, copied_path);
  320.     penum->pgs = pgs;
  321.     penum->copied_path = copied_path;
  322.     return 0;
  323. }
  324.  
  325. /* Enumerate the next element of a path. */
  326. /* If the path is finished, return 0; */
  327. /* otherwise, return the element type. */
  328. int
  329. gs_path_enum_next(gs_path_enum *penum, gs_point ppts[3])
  330. {    gs_fixed_point fpts[3];
  331.     gs_state *pgs = (gs_state *)penum->pgs;        /* discard const */
  332.     int pe_op = gx_path_enum_next(penum, fpts);
  333.     int code;
  334.  
  335.     switch ( pe_op )
  336.       {
  337.     case 0:                /* all done */
  338.     case gs_pe_closepath:
  339.         break;
  340.     case gs_pe_curveto:
  341.         if ( (code = gs_itransform(pgs,
  342.                        fixed2float(fpts[1].x),
  343.                        fixed2float(fpts[1].y),
  344.                        &ppts[1])) < 0 ||
  345.              (code = gs_itransform(pgs,
  346.                        fixed2float(fpts[2].x),
  347.                        fixed2float(fpts[2].y),
  348.                        &ppts[2])) < 0 )
  349.           return code;
  350.     case gs_pe_moveto:
  351.     case gs_pe_lineto:
  352.         if ( (code = gs_itransform(pgs,
  353.                        fixed2float(fpts[0].x),
  354.                        fixed2float(fpts[0].y),
  355.                        &ppts[0])) < 0 )
  356.           return code;
  357.     default:            /* error */
  358.         break;
  359.        }
  360.     return pe_op;
  361. }
  362.  
  363. /* Clean up after a pathforall. */
  364. void
  365. gs_path_enum_cleanup(gs_path_enum *penum)
  366. {    if ( penum->copied_path != 0 )        /* don't do it twice ... */
  367.                         /* shouldn't be needed! */
  368.     {    gx_path_release(penum->copied_path);
  369.         gs_free_object(penum->pgs->memory, penum->copied_path,
  370.                    "gs_path_enum_cleanup");
  371.         penum->path = 0;
  372.         penum->copied_path = 0;
  373.     }
  374. }
  375.